package com.distribute.framework.model;

import com.distribute.framework.core.web.helper.Utils;
import java.lang.reflect.Field;
import java.util.Date; 
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

import javax.annotation.Resource;

import com.distribute.framework.core.web.util.Page;
import com.distribute.framework.core.lang.*; 
import com.distribute.framework.core.web.helper.WebHelper.LzMap;
import com.distribute.framework.core.util.Function;
import com.distribute.framework.core.util.IbatisMap;
import com.distribute.framework.config.*;
import com.distribute.framework.plugin.*;

@namespace("systematic/eventtype")
public @caption("事件类型") @database(DatabaseNames.distribute_sys) @source("distribute_sys") @table("srv_event_type") class SrvEventType implements java.io.Serializable
{
	private static final long serialVersionUID = 1l;
	private @caption("编号") @column("set_id")    @primary  @notnull  @note("  ") Long setId;// 主键 非空     
	private @caption("类型名称") @column("set_name")     @notnull  @note("  ") String setName;// 非空     
	private @caption("事件级别") @column("set_level")     @notnull  @note(" 0:自定提示 1:强制提示 2:全员提示  ") Short setLevel;// 非空 0:自定提示 1:强制提示 2:全员提示     
	private @caption("时间间隔") @column("set_interval")      @note(" 0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月  ") Long setInterval;// 0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月     
	private @caption("修改时间") @column("set_update_time")     @notnull  @note("  ") Date setUpdateTime;// 非空     
	private @caption("添加时间") @column("set_add_time")     @notnull  @note("  ") Date setAddTime;// 非空     
	private @caption("状态") @column("set_status")     @notnull  @note(" 1:启用 0:禁用  ") Short setStatus;// 非空 1:启用 0:禁用     
	 
	//默认构造函数
	public SrvEventType(){ 
	
	}
	
	//主键构造函数
	public SrvEventType(Long id){
		this.setId = id;
	}
	
	/**所有字段构造函数 
	 SrvEventType(
	 	Utils.getString("setName")//类型名称 [非空]
	 	,Utils.getShort("setLevel")//事件级别 [非空]
	 	,Utils.getLong("setInterval")//时间间隔
	 	,Utils.getDate("setUpdateTime")//修改时间 [非空]
	 	,Utils.getDate("setAddTime")//添加时间 [非空]
	 	,Utils.getShort("setStatus")//状态 [非空]
	 )
	**/
	public SrvEventType(String setName,Short setLevel,Long setInterval,Date setUpdateTime,Date setAddTime,Short setStatus){
		this.setName=setName;
		this.setLevel=setLevel;
		this.setInterval=setInterval;
		this.setUpdateTime=setUpdateTime;
		this.setAddTime=setAddTime;
		this.setStatus=setStatus;
	}
	
	//设置非空字段
	public SrvEventType setNotNull(String setName,Short setLevel,Date setUpdateTime,Date setAddTime,Short setStatus){
		this.setName=setName;
		this.setLevel=setLevel;
		this.setUpdateTime=setUpdateTime;
		this.setAddTime=setAddTime;
		this.setStatus=setStatus;
		return this;
	}
	/** 编号 [非空]       **/
	public SrvEventType setId(Long setId){
		this.setId = setId;
		this.setSeted(F.setId);
		return this;
	}
	/** 类型名称 [非空]       **/
	public SrvEventType setName(String setName){
		this.setName = setName;
		this.setSeted(F.setName);
		return this;
	}
	/** 事件级别 [非空]   0:自定提示 1:强制提示 2:全员提示     **/
	public SrvEventType setLevel(Short setLevel){
		this.setLevel = setLevel;
		this.setSeted(F.setLevel);
		return this;
	}
	/** 时间间隔    0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月     **/
	public SrvEventType setInterval(Long setInterval){
		this.setInterval = setInterval;
		this.setSeted(F.setInterval);
		return this;
	}
	/** 修改时间 [非空]       **/
	public SrvEventType setUpdateTime(Date setUpdateTime){
		this.setUpdateTime = setUpdateTime;
		this.setSeted(F.setUpdateTime);
		return this;
	}
	/** 添加时间 [非空]       **/
	public SrvEventType setAddTime(Date setAddTime){
		this.setAddTime = setAddTime;
		this.setSeted(F.setAddTime);
		return this;
	}
	/** 状态 [非空]   1:启用 0:禁用     **/
	public SrvEventType setStatus(Short setStatus){
		this.setStatus = setStatus;
		this.setSeted(F.setStatus);
		return this;
	}
	
	
	/**
	* 克隆对象
	**/
	public SrvEventType clone(){
		SrvEventType clone = new SrvEventType();
		clone.setName=this.setName;
		clone.setLevel=this.setLevel;
		clone.setInterval=this.setInterval;
		clone.setUpdateTime=this.setUpdateTime;
		clone.setAddTime=this.setAddTime;
		clone.setStatus=this.setStatus;
		return clone;
	}
	/**
	* 清除缓存
	**/
	public void clear(){
		Cache.clearObject(SrvEventType.M.class);
		Cache.clearValue(SrvEventType.M.class);
		Cache.deleteObject(SrvEventType.class, this.getId());
	}
	
	/**
	* 清除缓存
	**/
	public static void clear(Long id){
		Cache.clearObject(SrvEventType.M.class);
		Cache.clearValue(SrvEventType.M.class);
		Cache.deleteObject(SrvEventType.class, id);
	}
	
	
	/**
	 * 根据ID取事件类型
	 * @param id
	 * @return
	 */
	public static @api SrvEventType get(Long id){		
		return getSrvEventTypeById(id);
	}
	
	/**
	 * 获取所有事件类型
	 * @return
	 */
	public static @api List<SrvEventType> list(Map params,Integer size){
		return getSrvEventTypeList(params,size);
	}
	/**
	 * 获取事件类型分页
	 * @return
	 */
	public static @api Page<SrvEventType> page(Integer page,Integer size,Map params){
		return getSrvEventTypePage(page, size , params);
	}
	
	
	/**
	 * 根据查询条件取事件类型
	 * @param params
	 * @return
	 */
	public static @api SrvEventType Get(Map params){
		return getSrvEventType(params);
	}
	/**
	 * 获取事件类型数
	 * @return
	 */
	public static @api Long count(Map params){
		return getSrvEventTypeCount(params);
	}
	/**
	 * 获取事件类型数
	 * @return
	 */
	public static @api <T> T eval(String eval,Map params){
		return getSrvEventTypeEval(eval,params);
	}
	/**
	 * 获取事件类型图表统计数据
	 * @param params 查询条件
	 * @param sumKey 统计的字段
	 * @param groupKey 1:按年， 2：按月， 3：按周， 4：按日， 5：按小时， 6：月分， 7：日分， 8：点分
	 * @return
	 */
	public static @api List<Map> stats(Map params,C sumKey,C groupKey){
		return getSrvEventTypeStats(params,sumKey,groupKey,-1);
	}
	/**
	 * 获取事件类型图表统计数据
	 * @param params 查询条件
	 * @param sumKey 统计的字段
	 * @param groupKey 分组的字段
	 * @param dateType 1:按年， 2：按月， 3：按周， 4：按日， 5：按小时， 6：月分， 7：日分， 8：点分
	 * @return
	 */
	public static @api List<Map> stats(Map params,C sumKey,C groupKey,int dateType){
		return getSrvEventTypeStats(params,sumKey,groupKey,dateType);
	}
	
	/**
	 * 根据ID取事件类型
	 * @param id
	 * @return
	 */
	public static @api SrvEventType getSrvEventTypeById(Long id){		
		return getSrvEventTypeDao().getSrvEventTypeById(id);
	}
	/**
	 * 获取id
	 * @return
	 */
	public Long getId(){
		return this.setId;
	}
	
	
	/**
	 * 根据ID取事件类型的标识键值
	 * @param id
	 * @return
	 */
	public static @api String getKeyValue(Object key){
		Long id = Utils.parseLong(key);	
		if(id==null || id.longValue()==0 ){
			return null;
		}
		String value = null;
		value = Cache.getValue(SrvEventType.class, id);
		if(value==null){
			SrvEventType srvEventType = get(id);
			if(srvEventType!=null){
				String strValue = srvEventType.getSetName$();
				if(!"SetName".equals("SetName"))
					strValue+="("+srvEventType.getSetName$()+")";
				Cache.setValue(SrvEventType.class, id ,strValue);
				value = strValue;
			}else{
				Cache.setValue(SrvEventType.class, id ,"{"+id+"}",30);
				value = "{"+id+"}";
			}
		}
		/************LAZY3Q_ID_KEYVALUE************/
		/************LAZY3Q_ID_KEYVALUE************/
		return value;
	}	
	
	
	/**
	 * 获取当前对象的键值
	 * @return
	 */
	public String getKeyValue(){
		/************LAZY3Q_CODE_KEYVALUE************/
		/************LAZY3Q_CODE_KEYVALUE************/
		String keyValue = this.getSetName$();
		if(!"SetName".equals("SetName"))
			keyValue+="("+this.getSetName$()+")";
		return keyValue;
	}
	
	
	/**
	 * 根据关键字精确查询事件类型对象
	 * @return
	 */
	public static @api SrvEventType find(String key){
		if(Utils.empty(key))return null;
		Map params = new HashMap();
		if(key.toLowerCase().startsWith("id:"))//如果查询条件以id:开头，则按ID查询
			params.put("setId", key.toLowerCase().replaceFirst("id:", ""));					
		else{//按标识查询，精确查询
			String strDefinex = "";
			strDefinex+=" or set_name = '"+key.replaceAll("'", "''")+"'";
			strDefinex="(2=1 "+strDefinex+")";
			params.put("definex",strDefinex);
		}
		/************LAZY3Q_CODE_FIND************/
		/************LAZY3Q_CODE_FIND************/
		return SrvEventType.getSrvEventType(params);
	}
	
	
	/**
	 * 根据关键字查询事件类型
	 * @return
	 */
	public static @api List<Map> query(String key,int size,Map params,Boolean bObject){
		if(Utils.empty((String)params.get("asc")) && Utils.empty((String)params.get("desc")))//如果未传入排序字段
			params.put("desc","set_id");//那么，默认以主键降序，传给Dao层
		String strTerm=key;		
		if(!Utils.empty(strTerm)){
			if(strTerm.toLowerCase().startsWith("id:"))//如果查询条件以id:开头，则按ID查询
				params.put("setId", strTerm.toLowerCase().replaceFirst("id:", ""));					
			else//按标识查询，模糊查询请带%
			{
				String strDefinex = "";
				strDefinex+=" or set_name like '%"+strTerm.replaceAll("'", "''")+"%'";
				strDefinex="(2=1 "+strDefinex+")";
				params.put("definex",strDefinex);
			}
		}
		/************LAZY3Q_CODE_QUERY************/
		/************LAZY3Q_CODE_QUERY************/
			
		List<SrvEventType> list = page(0,size,params).getResult();
		
		/**
		* OK!取到数据拼成放入Map中，[{value,text,object:{...}},...]
		* value:数据ID，text:数据标识,object,整个对象
		**/
		List<Map> result = new java.util.ArrayList();
		for(SrvEventType srvEventType:list){
			Map map = new HashMap();
			map.put("key",srvEventType.getSetId().toString());
			map.put("value", Utils.js(srvEventType.getKeyValue()));
			if(bObject==true)
				map.put("object",srvEventType);
			result.add(map);
		}
		/************LAZY3Q_AFTER_QUERY************/
		/************LAZY3Q_AFTER_QUERY************/
		
		return result;
	}
	
	
	
	/**
	 * 获取所有事件类型
	 * @return
	 */
	public static @api List<SrvEventType> getSrvEventTypeList(Map params,Integer size){
		return getSrvEventTypeDao().getSrvEventTypeList(params,0,size);
	}
	
	/**
	 * 获取事件类型分页
	 * @return
	 */
	public static @api Page<SrvEventType> getSrvEventTypePage(Integer page,Integer size,Map params){
		if(page==null)page=0;
		if(size==null)size=20;
		return getSrvEventTypeDao().getSrvEventTypePage(page, size , params);
	}
	
	/**
	 * 根据查询条件取事件类型
	 * @param params
	 * @return
	 */
	public static @api SrvEventType getSrvEventType(Map params){
		return getSrvEventTypeDao().getSrvEventType(params);
	}
	
	/**
	 * 保存一个事件类型
	 * @param srvEventType
	 * @return
	 */
	public static @api SrvEventType saveSrvEventType(SrvEventType srvEventType){
		return getSrvEventTypeDao().saveSrvEventType(srvEventType);
	}
	
	/**
	 * 根据条件更新事件类型
	 * @param values
	 * @param params
	 */
	public static @api int updateSrvEventTypeByConfirm(Map values, Map params){
		return getSrvEventTypeDao().updateSrvEventTypeByConfirm(values,params);
	}
	
	/**
	 * 修改一个事件类型
	 * @param srvEventType
	 * @return
	 */
	public static @api int updateSrvEventType(SrvEventType srvEventType){
		return getSrvEventTypeDao().updateSrvEventType(srvEventType);
	}
	
	/**
	 * 更新事件类型非空字段
	 * @param srvEventType
	 */
	public static @api int updateSrvEventType$NotNull(SrvEventType srvEventType){
		return getSrvEventTypeDao().updateSrvEventType$NotNull(srvEventType);
	}
	
	/**
	 * 获取事件类型数
	 * @return
	 */
	public static @api Long getSrvEventTypeCount(Map params){
		return getSrvEventTypeDao().getSrvEventTypeCount(params);
	}
		
		
	/**
	 * 获取事件类型自定义求和表达式,比如求和:eval="sum(id)"
	 * @return
	 */	
	public static @api <T> T getSrvEventTypeEval(String eval,Map params){
		return getSrvEventTypeDao().getSrvEventTypeEval(eval,params);
	}
	/**
	 * 获取事件类型图表统计数据
	 * @param params 查询条件
	 * @param sumKey 统计的字段
	 * @param groupKey 分组的字段
	 * @param dateType 1:按年， 2：按月， 3：按周， 4：按日， 5：按小时， 6：月分， 7：日分， 8：点分
	 * @return
	 */
	public static @api List<Map> getSrvEventTypeStats(Map params,C sumKey,C groupKey,int dateType){
		//TODO:图表统计功能未实现
		
		Map<String,Object> groups=new HashMap();//要分组的字段
		Map<String,Object> sums=new HashMap();//要统计的字段
		
		String[][] dateFormats=new String[][]{
				null,
				new String[]{"%Y","yyyy年","Y"},
				new String[]{"%Y-%m","yyyy年MM月","M"},
				new String[]{"%Y%U","yyyy年第ww周","W"},
				new String[]{"%Y-%m-%d","yyyy年MM月dd日","D"},
				new String[]{"%Y-%m-%d %H","yyyy年MM月dd日 HH点","H"},
				new String[]{"%m","MM月"},
				new String[]{"%d","dd号"},
				new String[]{"%H","HH点"} 
		};
		
		//获取要分组的字段，放入Map中
		if(dateType>0){
			groups.put(groupKey.toString(),"DATE_FORMAT({key},'"+dateFormats[dateType][0]+"')");
		}else{
			groups.put(groupKey.toString(),"{key}");
		}
		if(dateType<6 && dateType>0){ 
			params.put("asc", groupKey.toString()); 
			if(params.get(groupKey.name()+"Start")==null){
				params.put(groupKey.name()+"Start", Utils.date(new Date(), -24, dateFormats[dateType][2]));
			}
		}
		
		
		//获取要统计的字段，放入Map中
		if(sumKey.toString().equals("count")){
			sums.put(sumKey.toString(),"count(*)");
		}else{
			sums.put(sumKey.toString(),"sum({key})");
		}
		
		List<Map> list = getSrvEventTypeDao().getSrvEventTypeStats(params,groups,sums);
		
		List<Map> result = new ArrayList();
		for(Map m:list){
			Map map = new HashMap();
			Object value = m.get(sumKey.toString());
			Object name = null;
			Object groupValue = m.get(groupKey.toString());
			if(dateType>0){
				name = Utils.date(Utils.parseDate(groupValue), dateFormats[dateType][1]);
			}else{
				try{
					java.lang.reflect.Method method = SrvEventType.class.getMethod("get"+Utils.ForMat(groupKey.toString())+"$");
					method.setAccessible(true);
					name = method.invoke(SrvEventType.fromMap(m));
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			map.put("name", name);
			map.put("value", value);
			result.add(map);
		}
		return result;
	}
	
	/**
	 * 根据条件更新数据
	 * @param set
	 * @param where
	 */
	public static int updateSrvEventType(Map set,Map where){
		if(set.isEmpty())throw new RuntimeException("set为空");
		if(where.isEmpty())throw new RuntimeException("where为空");
		where.put("confirm", "1");
		return getSrvEventTypeDao().updateSrvEventTypeByConfirm(set, where);
	}
	
	
	/**
	 * 根据条件更新数据
	 * @param set
	 * @param where
	 */
	public static void deleteSrvEventType(Map where){
		if(where.isEmpty())throw new RuntimeException("where为空");
		where.put("confirm", "1");
		getSrvEventTypeDao().deleteSrvEventTypeByConfirm(where);
	}
	
	/**
	 * 根据条件更新数据
	 * @param set
	 * @param where
	 */
	public static void delete(Long id){
		if(id==null)throw new RuntimeException("id为空");
		getSrvEventTypeDao().removeSrvEventTypeById(id);
	}
	
	
	/**
	 * 保存事件类型对象
	 * @param params
	 * @return
	 */
	public SrvEventType save(){
		if(this.getSetId()!=null)
			getSrvEventTypeDao().updateSrvEventType(this);
		else
			return getSrvEventTypeDao().saveSrvEventType(this);
		return this;
	}
	
	
	/**
	 * 更新事件类型对象的非空字段,注意跟Service里面的update不一样哦
	 * @param params
	 * @return
	 */
	public int update(){
		return getSrvEventTypeDao().updateSrvEventType$NotNull(this);
	}
	
	
	/**
	 * 删除
	 * @param params
	 * @return
	 */
	public void delete(){
		if(Utils.equals(Utils.config("logic_delete"),"true"))
			getSrvEventTypeDao().removeSrvEventTypeById(this.getSetId());
		else
			getSrvEventTypeDao().deleteSrvEventTypeById(this.getSetId());
	}
	
	/**
	 * 执行事务
	 * @param function
	 */
	public static <T> T execute(Function function){
		return getSrvEventTypeDao().executeTransaction(function);
	}
	/*******************************编号**********************************/	
	/**
	* 编号 [非空]      
	**/
	public Long getSetId(){
		if(this.setId!=null){
			return this.setId;
		}
		return this.setId;
	}
	/**
	* 获取编号格式化(toString)
	**/
	public String getSetId$(){
		String strValue="";
		 strValue=Utils.string(this.getSetId());
	 	 return strValue;
	}
	/**
	* 根据编号反格式化
	**/
	public void setSetId$(String strValue){
		if(Utils.empty(strValue)){
			this.setId=null;
			return;
		}
	 	this.setId=Utils.parseLong(strValue);
	}
	
	/**
	* 编号 [非空]      
	**/
	public void setSetId(Long setId){
		this.setId = setId;
		this.setSeted(F.setId);
	}
	
	
	
	
	/*******************************类型名称**********************************/	
	/**
	* 类型名称 [非空]      
	**/
	public String getSetName(){
		if(this.setName!=null){
			return this.setName;
		}
		return this.setName;
	}
	/**
	* 获取类型名称格式化(toString)
	**/
	public String getSetName$(){
		String strValue="";
		 strValue=Utils.string(this.getSetName());
	 	 return strValue;
	}
	/**
	* 根据类型名称反格式化
	**/
	public void setSetName$(String strValue){
		if(Utils.empty(strValue)){
			this.setName=null;
			return;
		}
	 	this.setName=strValue;
	}
	
	/**
	* 类型名称 [非空]      
	**/
	public void setSetName(String setName){
		this.setName = setName;
		this.setSeted(F.setName);
	}
	
	
	
	
	/*******************************事件级别**********************************/	
	/**
	* 事件级别 [非空]   0:自定提示 1:强制提示 2:全员提示    
	**/
	public Short getSetLevel(){
		if(this.setLevel!=null){
			return this.setLevel;
		}
		return this.setLevel;
	}
	/**
	* 获取事件级别格式化(toString)
	**/
	public String getSetLevel$(){
		String strValue="";
		 if(Utils.equals(Utils.string(this.getSetLevel()),"0"))
			strValue=Utils.string("自定提示");		 
		 if(Utils.equals(Utils.string(this.getSetLevel()),"1"))
			strValue=Utils.string("强制提示");		 
		 if(Utils.equals(Utils.string(this.getSetLevel()),"2"))
			strValue=Utils.string("全员提示");		 
	 	 return strValue;
	}
	/**
	* 根据事件级别反格式化
	**/
	public void setSetLevel$(String strValue){
		if(Utils.empty(strValue)){
			this.setLevel=null;
			return;
		}
		 if(Utils.equals(strValue,"自定提示"))
		 	this.setLevel=Utils.parseShort("0");
		 if(Utils.equals(strValue,"强制提示"))
		 	this.setLevel=Utils.parseShort("1");
		 if(Utils.equals(strValue,"全员提示"))
		 	this.setLevel=Utils.parseShort("2");
	}
	
	/**
	* 事件级别 [非空]   0:自定提示 1:强制提示 2:全员提示    
	**/
	public void setSetLevel(Short setLevel){
		this.setLevel = setLevel;
		this.setSeted(F.setLevel);
	}
	
	
	
	
	/*******************************时间间隔**********************************/	
	/**
	* 时间间隔    0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月    
	**/
	public Long getSetInterval(){
		if(this.setInterval!=null){
			return this.setInterval;
		}
		return this.setInterval;
	}
	/**
	* 获取时间间隔格式化(toString)
	**/
	public String getSetInterval$(){
		String strValue="";
		 if(Utils.equals(Utils.string(this.getSetInterval()),"0"))
			strValue=Utils.string("不限制");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"60"))
			strValue=Utils.string("一分钟");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"600"))
			strValue=Utils.string("十分钟");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"1800"))
			strValue=Utils.string("半小时");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"3600"))
			strValue=Utils.string("一小时");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"7200"))
			strValue=Utils.string("两小时");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"43200"))
			strValue=Utils.string("半天");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"86400"))
			strValue=Utils.string("一天");		 
		 if(Utils.equals(Utils.string(this.getSetInterval()),"2592000"))
			strValue=Utils.string("一个月");		 
	 	 return strValue;
	}
	/**
	* 根据时间间隔反格式化
	**/
	public void setSetInterval$(String strValue){
		if(Utils.empty(strValue)){
			this.setInterval=null;
			return;
		}
		 if(Utils.equals(strValue,"不限制"))
		 	this.setInterval=Utils.parseLong("0");
		 if(Utils.equals(strValue,"一分钟"))
		 	this.setInterval=Utils.parseLong("60");
		 if(Utils.equals(strValue,"十分钟"))
		 	this.setInterval=Utils.parseLong("600");
		 if(Utils.equals(strValue,"半小时"))
		 	this.setInterval=Utils.parseLong("1800");
		 if(Utils.equals(strValue,"一小时"))
		 	this.setInterval=Utils.parseLong("3600");
		 if(Utils.equals(strValue,"两小时"))
		 	this.setInterval=Utils.parseLong("7200");
		 if(Utils.equals(strValue,"半天"))
		 	this.setInterval=Utils.parseLong("43200");
		 if(Utils.equals(strValue,"一天"))
		 	this.setInterval=Utils.parseLong("86400");
		 if(Utils.equals(strValue,"一个月"))
		 	this.setInterval=Utils.parseLong("2592000");
	}
	
	/**
	* 时间间隔    0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月    
	**/
	public void setSetInterval(Long setInterval){
		this.setInterval = setInterval;
		this.setSeted(F.setInterval);
	}
	
	
	
	
	/*******************************修改时间**********************************/	
	/**
	* 修改时间 [非空]      
	**/
	public Date getSetUpdateTime(){
		if(this.setUpdateTime!=null){
			return this.setUpdateTime;
		}
		return this.setUpdateTime;
	}
	/**
	* 获取修改时间格式化(toString)
	**/
	public String getSetUpdateTime$(){
		String strValue="";
		 strValue=Utils.string(Utils.date(this.getSetUpdateTime(),"yyyy-MM-dd HH:mm:ss"));
	 	 return strValue;
	}
	/**
	* 根据修改时间反格式化
	**/
	public void setSetUpdateTime$(String strValue){
		if(Utils.empty(strValue)){
			this.setUpdateTime=null;
			return;
		}
	 	this.setUpdateTime=Utils.date(strValue,"yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	* 修改时间 [非空]      
	**/
	public void setSetUpdateTime(Date setUpdateTime){
		this.setUpdateTime = setUpdateTime;
		this.setSeted(F.setUpdateTime);
	}
	
	
	
	
	/*******************************添加时间**********************************/	
	/**
	* 添加时间 [非空]      
	**/
	public Date getSetAddTime(){
		if(this.setAddTime!=null){
			return this.setAddTime;
		}
		return this.setAddTime;
	}
	/**
	* 获取添加时间格式化(toString)
	**/
	public String getSetAddTime$(){
		String strValue="";
		 strValue=Utils.string(Utils.date(this.getSetAddTime(),"yyyy-MM-dd HH:mm:ss"));
	 	 return strValue;
	}
	/**
	* 根据添加时间反格式化
	**/
	public void setSetAddTime$(String strValue){
		if(Utils.empty(strValue)){
			this.setAddTime=null;
			return;
		}
	 	this.setAddTime=Utils.date(strValue,"yyyy-MM-dd HH:mm:ss");
	}
	
	/**
	* 添加时间 [非空]      
	**/
	public void setSetAddTime(Date setAddTime){
		this.setAddTime = setAddTime;
		this.setSeted(F.setAddTime);
	}
	
	
	
	
	/*******************************状态**********************************/	
	/**
	* 状态 [非空]   1:启用 0:禁用    
	**/
	public Short getSetStatus(){
		if(this.setStatus!=null){
			return this.setStatus;
		}
		return this.setStatus;
	}
	/**
	* 获取状态格式化(toString)
	**/
	public String getSetStatus$(){
		String strValue="";
		 if(Utils.equals(Utils.string(this.getSetStatus()),"1"))
			strValue=Utils.string("启用");		 
		 if(Utils.equals(Utils.string(this.getSetStatus()),"0"))
			strValue=Utils.string("禁用");		 
	 	 return strValue;
	}
	/**
	* 根据状态反格式化
	**/
	public void setSetStatus$(String strValue){
		if(Utils.empty(strValue)){
			this.setStatus=null;
			return;
		}
		 if(Utils.equals(strValue,"启用"))
		 	this.setStatus=Utils.parseShort("1");
		 if(Utils.equals(strValue,"禁用"))
		 	this.setStatus=Utils.parseShort("0");
	}
	
	/**
	* 状态 [非空]   1:启用 0:禁用    
	**/
	public void setSetStatus(Short setStatus){
		this.setStatus = setStatus;
		this.setSeted(F.setStatus);
	}
	
	
	
	
	/************LAZY3Q_DEFINE_CODE************/
	/************LAZY3Q_DEFINE_CODE************/
	
	
	/**
	 * 触发器
	 */
	public static void on(Trigger.Index index,final Notify.Listener listener,Trigger.Type... types){
		Notify.on(SrvEventType.class, index, listener, types);
	}
	public static void on(final Notify.Listener listener,String type){
		Notify.on(SrvEventType.class, listener, type);
	}
	/**
	 * 当修改字段时
	 * @param filedName
	 * @param listener
	 */
	public static void on(String filedName,final Notify.Listener listener){
		Notify.on(SrvEventType.class, listener, filedName);
	}
	/**
	 * 当修改字段为某值时
	 * @param filedName
	 * @param value
	 * @param listener
	 */
	public static void on(String filedName,Object value,final Notify.Listener listener){
		if(value==null)return;
		Notify.on(SrvEventType.class, listener, filedName+"."+Utils.md5(""+value));
	}
	public void notify(String type){
		Trigger.on(SrvEventType.class,type, this);
	}
	
	
	/**
	 * 用来获取当有字段关联对象时的获取方式,调用如${SrvEventType.obj.filedName}
	 * 因为有些变态的模板语言不能识别$，所以不能以${SrvEventType.$filedName}获取关联对象
	 */
	public Map getObj(){
		return new HashMap(){
			@Override
			public Object get(Object key) {
				try {
					return SrvEventType.class.getMethod("get$"+Utils.forMat(key.toString())).invoke(SrvEventType.this);
				} catch (Exception e) {
					e.printStackTrace();
				}
				return null;
			}
		};
	}
	/**
	 * 用来获取某字段格式化的获取方式,调用如${SrvEventType.fmt.filedName}
	 * 因为有些变态的模板语言不能识别$，所以不能以${SrvEventType.filedName$}获取某字段格式化
	 */
	public Map getFmt(){
		return new HashMap(){
			@Override
			public Object get(Object key) {
				try {
					return SrvEventType.class.getMethod("get"+Utils.ForMat(key.toString()+"$")).invoke(SrvEventType.this);
				} catch (Exception e) {
					e.printStackTrace();
				}
				return null;
			}
		};
	}
	/**
	 * 获取查询参数链式串
	 * @return
	 */
	public static @Deprecated M where(){ return new M(0); }
	public static @Deprecated M m(){ return new M(0); }
	public static M where = new M(0,true);
	public static @database(DatabaseNames.distribute_sys) class M extends IbatisMap{
		int type = 0; 
		M linked = null;
		Boolean proxy = false;
		public M set = null;
		public M(int type){
			this.type = type;
			if(this.type==0){
				set = new M(1,true);
				set.linked = this;
			}
		};
		public M(int type,Boolean proxy){
			this.type = type;
			this.proxy=proxy;
		};
		public M proxy(){
			M m = new M(this.type);//当前的对像
			if(this.type==0){
				m.set = new M(1,true);//set对象
				m.set.linked = m;
			}else{
				m.linked=this.linked;
				this.linked.linked=m;
			}
			return m;
		}
		public @Deprecated M set(){			
			M m = this;
			m.linked=new M(1);
			m.linked.linked=m;
			return m.linked;
		};
		public M on(IbatisMap value,C column,String joinColumn){if(proxy)return proxy().on(value,column,joinColumn);this.put(value.getClass().getDeclaringClass().getSimpleName(), value);value.put("on", column.toString());value.put("to", joinColumn);return this;};
		/** 编号 [非空]       **/
		public M setId(Object setId){if(proxy)return proxy().setId(setId);  this.put("setId", setId);return this;};
	 	/** and set_id is null */
 		public M setIdNull(){if(proxy)return proxy().setIdNull();if(this.get("setIdNot")==null)this.put("setIdNot", "");this.put("setId", null);return this;};
 		/** not .... */
 		public M setIdNot(){if(proxy)return proxy().setIdNot();this.put("setIdNot", "not");return this;};
 		public M setIdNotNull(){if(proxy)return proxy().setIdNotNull();this.put("setIdNot", "not");this.put("setId", null);return this;};
 		public M setIdNot(Object setId){if(proxy)return proxy().setIdNot(setId);this.put("setIdNot", "not");this.put("setId", setId);return this;};
		/** and set_id <= ? */
		public M setIdMin(Object min){if(proxy)return proxy().setIdMin(min);this.put("setIdMin", min);return this;};
		/** and set_id >= ? */
		public M setIdMax(Object max){if(proxy)return proxy().setIdMax(max);this.put("setIdMax", max);return this;};
		public M setIdIn(String ids){
			if(proxy)return proxy().setIdIn(ids);  this.put("setIdIn", ids);return this;
		};	
		/** 类型名称 [非空]       **/
		public M setName(Object setName){if(proxy)return proxy().setName(setName);  this.put("setName", setName);return this;};
	 	/** and set_name is null */
 		public M setNameNull(){if(proxy)return proxy().setNameNull();if(this.get("setNameNot")==null)this.put("setNameNot", "");this.put("setName", null);return this;};
 		/** not .... */
 		public M setNameNot(){if(proxy)return proxy().setNameNot();this.put("setNameNot", "not");return this;};
 		public M setNameNotNull(){if(proxy)return proxy().setNameNotNull();this.put("setNameNot", "not");this.put("setName", null);return this;};
 		public M setNameNot(Object setName){if(proxy)return proxy().setNameNot(setName);this.put("setNameNot", "not");this.put("setName", setName);return this;};
		/** 事件级别 [非空]   0:自定提示 1:强制提示 2:全员提示     **/
		public M setLevel(Object setLevel){if(proxy)return proxy().setLevel(setLevel);  this.put("setLevel", setLevel);return this;};
	 	/** and set_level is null */
 		public M setLevelNull(){if(proxy)return proxy().setLevelNull();if(this.get("setLevelNot")==null)this.put("setLevelNot", "");this.put("setLevel", null);return this;};
 		/** not .... */
 		public M setLevelNot(){if(proxy)return proxy().setLevelNot();this.put("setLevelNot", "not");return this;};
 		public M setLevelNotNull(){if(proxy)return proxy().setLevelNotNull();this.put("setLevelNot", "not");this.put("setLevel", null);return this;};
 		public M setLevelNot(Object setLevel){if(proxy)return proxy().setLevelNot(setLevel);this.put("setLevelNot", "not");this.put("setLevel", setLevel);return this;};
		public M setLevelIn(String ids){
			if(proxy)return proxy().setLevelIn(ids);  this.put("setLevelIn", ids);return this;
		};	
		/** 时间间隔    0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月     **/
		public M setInterval(Object setInterval){if(proxy)return proxy().setInterval(setInterval);  this.put("setInterval", setInterval);return this;};
	 	/** and set_interval is null */
 		public M setIntervalNull(){if(proxy)return proxy().setIntervalNull();if(this.get("setIntervalNot")==null)this.put("setIntervalNot", "");this.put("setInterval", null);return this;};
 		/** not .... */
 		public M setIntervalNot(){if(proxy)return proxy().setIntervalNot();this.put("setIntervalNot", "not");return this;};
 		public M setIntervalNotNull(){if(proxy)return proxy().setIntervalNotNull();this.put("setIntervalNot", "not");this.put("setInterval", null);return this;};
 		public M setIntervalNot(Object setInterval){if(proxy)return proxy().setIntervalNot(setInterval);this.put("setIntervalNot", "not");this.put("setInterval", setInterval);return this;};
		public M setIntervalIn(String ids){
			if(proxy)return proxy().setIntervalIn(ids);  this.put("setIntervalIn", ids);return this;
		};	
		/** 修改时间 [非空]       **/
		public M setUpdateTime(Object setUpdateTime){if(proxy)return proxy().setUpdateTime(setUpdateTime);  this.put("setUpdateTime", setUpdateTime);return this;};
	 	/** and set_update_time is null */
 		public M setUpdateTimeNull(){if(proxy)return proxy().setUpdateTimeNull();if(this.get("setUpdateTimeNot")==null)this.put("setUpdateTimeNot", "");this.put("setUpdateTime", null);return this;};
 		/** not .... */
 		public M setUpdateTimeNot(){if(proxy)return proxy().setUpdateTimeNot();this.put("setUpdateTimeNot", "not");return this;};
 		public M setUpdateTimeNotNull(){if(proxy)return proxy().setUpdateTimeNotNull();this.put("setUpdateTimeNot", "not");this.put("setUpdateTime", null);return this;};
 		public M setUpdateTimeNot(Object setUpdateTime){if(proxy)return proxy().setUpdateTimeNot(setUpdateTime);this.put("setUpdateTimeNot", "not");this.put("setUpdateTime", setUpdateTime);return this;};
 		/** and set_update_time >= ? */
 		public M setUpdateTimeStart(Object start){if(proxy)return proxy().setUpdateTimeStart(start);this.put("setUpdateTimeStart", start);return this;};			
 		/** and set_update_time <= ? */
 		public M setUpdateTimeEnd(Object end){if(proxy)return proxy().setUpdateTimeEnd(end);this.put("setUpdateTimeEnd", end);return this;};
		/** 添加时间 [非空]       **/
		public M setAddTime(Object setAddTime){if(proxy)return proxy().setAddTime(setAddTime);  this.put("setAddTime", setAddTime);return this;};
	 	/** and set_add_time is null */
 		public M setAddTimeNull(){if(proxy)return proxy().setAddTimeNull();if(this.get("setAddTimeNot")==null)this.put("setAddTimeNot", "");this.put("setAddTime", null);return this;};
 		/** not .... */
 		public M setAddTimeNot(){if(proxy)return proxy().setAddTimeNot();this.put("setAddTimeNot", "not");return this;};
 		public M setAddTimeNotNull(){if(proxy)return proxy().setAddTimeNotNull();this.put("setAddTimeNot", "not");this.put("setAddTime", null);return this;};
 		public M setAddTimeNot(Object setAddTime){if(proxy)return proxy().setAddTimeNot(setAddTime);this.put("setAddTimeNot", "not");this.put("setAddTime", setAddTime);return this;};
 		/** and set_add_time >= ? */
 		public M setAddTimeStart(Object start){if(proxy)return proxy().setAddTimeStart(start);this.put("setAddTimeStart", start);return this;};			
 		/** and set_add_time <= ? */
 		public M setAddTimeEnd(Object end){if(proxy)return proxy().setAddTimeEnd(end);this.put("setAddTimeEnd", end);return this;};
		/** 状态 [非空]   1:启用 0:禁用     **/
		public M setStatus(Object setStatus){if(proxy)return proxy().setStatus(setStatus);  this.put("setStatus", setStatus);return this;};
	 	/** and set_status is null */
 		public M setStatusNull(){if(proxy)return proxy().setStatusNull();if(this.get("setStatusNot")==null)this.put("setStatusNot", "");this.put("setStatus", null);return this;};
 		/** not .... */
 		public M setStatusNot(){if(proxy)return proxy().setStatusNot();this.put("setStatusNot", "not");return this;};
 		public M setStatusNotNull(){if(proxy)return proxy().setStatusNotNull();this.put("setStatusNot", "not");this.put("setStatus", null);return this;};
 		public M setStatusNot(Object setStatus){if(proxy)return proxy().setStatusNot(setStatus);this.put("setStatusNot", "not");this.put("setStatus", setStatus);return this;};
		public M setStatusIn(String ids){
			if(proxy)return proxy().setStatusIn(ids);  this.put("setStatusIn", ids);return this;
		};	
	 	public M add(String key, Object value) {if(proxy)return proxy().add(key,value);this.put(key, value);return this;}
	 	public M add(F key, Object value) {if(proxy)return proxy().add(key,value);this.put(key.toString(), value);return this;}
	 	public M desc(C key) {if(proxy)return proxy().desc(key);this.put("desc", key.column);return this;}
	 	public M asc(C key) {if(proxy)return proxy().asc(key);this.put("asc", key.column);return this;}
	 	public M desc(String sql) {if(proxy)return proxy().desc(sql);this.put("desc", sql);return this;}
	 	public M asc(String sql) {if(proxy)return proxy().asc(sql);this.put("asc", sql);return this;}
	 	public M definex(String sql) {if(proxy)return proxy().definex(sql);this.put("definex", sql);return this;}
	 	/** 获取所有事件类型 **/
		public @api List<SrvEventType> list(Integer size){			
			return getSrvEventTypeList(this,size);
		}
		/** 获取事件类型分页 **/
		public @api Page<SrvEventType> page(Integer page,Integer size){			
			return getSrvEventTypePage(page, size , this);
		}
		/** 根据查询条件取事件类型 **/
		public @api SrvEventType get(){			
			return getSrvEventType(this);
		}
		/** 获取事件类型数 **/
		public @api Long count(){			
			return getSrvEventTypeCount(this);
		}
		/** 获取事件类型表达式 **/
		public @api <T> T eval(String strEval){			
			return getSrvEventTypeEval(strEval,this);
		}
		/** 获取事件类型统计 **/
		public @api List<Map> stats(C sumKey,C groupKey,int dateType){			
			return getSrvEventTypeStats(this,sumKey,groupKey,dateType);
		}
		/** 获取事件类型统计 **/
		public @api List<Map> stats(C sumKey,C groupKey){			
			return getSrvEventTypeStats(this,sumKey,groupKey,-1);
		}
		/** 根据条件更新 **/
		public @api int update(){			
			M where = null;
			M set = null;
			if(this.type==0){
				if(this.linked==null)throw new RuntimeException("未发set");
				where = this;
				set = this.linked;
			}else{
				if(this.linked==null)throw new RuntimeException("未发where条件");
				set = this;
				where = this.linked;
			}
			return updateSrvEventType(set,where);
		}
		/** 根据条件删除 **/
		public @api void delete(){			
			deleteSrvEventType(this);
		}
	}
	
	public static class Param extends M{
		public Param(int type) {
			super(type);
		}
		public Param(int type, Boolean proxy) {
			super(type, proxy);
		}
	}
	
	/** 对象的字段描述 **/
	public static class F{
		/** 编号 [非空]       **/
		public final static @type(Long.class)  String setId="setId";
		/** 类型名称 [非空]       **/
		public final static @type(String.class)  String setName="setName";
		/** 事件级别 [非空]   0:自定提示 1:强制提示 2:全员提示     **/
		public final static @type(Short.class)  String setLevel="setLevel";
		/** 时间间隔    0:不限制 60:一分钟 600:十分钟 1800:半小时 3600:一小时 7200:两小时 43200:半天 86400:一天 2592000:一个月     **/
		public final static @type(Long.class)  String setInterval="setInterval";
		/** 修改时间 [非空]       **/
		public final static @type(Date.class)  String setUpdateTime="setUpdateTime";
	 	/** and set_update_time >= ? */
 		public final static @type(Date.class) String setUpdateTimeStart="setUpdateTimeStart";
 		/** and set_update_time <= ? */
 		public final static @type(Date.class) String setUpdateTimeEnd="setUpdateTimeEnd";
		/** 添加时间 [非空]       **/
		public final static @type(Date.class)  String setAddTime="setAddTime";
	 	/** and set_add_time >= ? */
 		public final static @type(Date.class) String setAddTimeStart="setAddTimeStart";
 		/** and set_add_time <= ? */
 		public final static @type(Date.class) String setAddTimeEnd="setAddTimeEnd";
		/** 状态 [非空]   1:启用 0:禁用     **/
		public final static @type(Short.class)  String setStatus="setStatus";
	 	public static String get(String name){
			try {
				Field field = F.class.getField(name);
				if(field!=null)
					return field.get(null).toString();
			} catch (Exception e) {
				//e.printStackTrace();
			}
			return null;
		}
	}
	/** 对象的数据库字段描述 **/
	public static enum C{
		setId("set_id"),
		setName("set_name"),
		setLevel("set_level"),
		setInterval("set_interval"),
		setUpdateTime("set_update_time"),
		setAddTime("set_add_time"),
		setStatus("set_status"),
		count("count");
		String column;
		C(String column){
			this.column = column;
		}
		public String toString(){
			return this.column;
		}
		public static String get(String name){
			try {
				Field field = C.class.getField(name);
				if(field!=null)
					return field.get(null).toString();
			} catch (Exception e) {
				//e.printStackTrace();
			}
			return null;
		}
	}
	
	
	
	/**
	* 获取事件类型数据
	**/
	public static Object getData(Object param){
		if(param==null)
			return null;
		Object value = null;
		if(param.getClass()==Long.class)
			value = SrvEventType.get((Long)param);
		else if(param instanceof java.util.Map){
			java.util.Map params = (Map) param;
			if(params.get("size")==null)
				value = SrvEventType.getSrvEventType(params);
			else
				value = SrvEventType.getSrvEventTypeList(params, (Integer) params.get("size"));
		}else if(param.getClass()==Long.class )
			value =  SrvEventType.where().setId(param).get();
		else if(!Utils.empty(param.toString()))
			value = SrvEventType.get(Long.valueOf(param.toString()));
		return value;
	}
	
	/**对象转json**/
	public Map toJSON(){
		return toJSON(false);
	}
	public Map toJSON(boolean simple){
		Map map = new HashMap();
		map.put("id",this.getSetId());
		Utils.fms(map,simple?"id":"setId",this.getSetId(),this.getSetId$());
		Utils.fms(map,simple?"name":"setName",this.getSetName(),this.getSetName$());
		Utils.fms(map,simple?"level":"setLevel",this.getSetLevel(),this.getSetLevel$());
		Utils.fms(map,simple?"interval":"setInterval",this.getSetInterval(),this.getSetInterval$());
		Utils.fms(map,simple?"updateTime":"setUpdateTime",this.getSetUpdateTime(),this.getSetUpdateTime$());
		Utils.fms(map,simple?"addTime":"setAddTime",this.getSetAddTime(),this.getSetAddTime$());
		Utils.fms(map,simple?"status":"setStatus",this.getSetStatus(),this.getSetStatus$());
		if(this.suffix!=null)map.put("suffix", this.suffix);
		/************LAZY3Q_DEFINE_TOJSON************/
		/************LAZY3Q_DEFINE_TOJSON************/
		return map;
	}
	/**对象转map**/
	public Map toMap(){
		Map map = new HashMap();
		map.put("setId",this.getSetId());
		map.put("setName",this.getSetName());
		map.put("setLevel",this.getSetLevel());
		map.put("setInterval",this.getSetInterval());
		map.put("setUpdateTime",this.getSetUpdateTime());
		map.put("setAddTime",this.getSetAddTime());
		map.put("setStatus",this.getSetStatus());
		map.put("suffix", this.suffix);
		/************LAZY3Q_DEFINE_TOMAP************/
		/************LAZY3Q_DEFINE_TOMAP************/
		return map;
	}
	/**map转对象**/
	public static SrvEventType fromMap(Map map){
		SrvEventType srvEventType = new SrvEventType();
		srvEventType.setId = Utils.parseLong(map.get("setId"));
		srvEventType.setName = Utils.parseString(map.get("setName"));
		srvEventType.setLevel = Utils.parseShort(map.get("setLevel"));
		srvEventType.setInterval = Utils.parseLong(map.get("setInterval"));
		srvEventType.setUpdateTime = Utils.parseDate(map.get("setUpdateTime"));
		srvEventType.setAddTime = Utils.parseDate(map.get("setAddTime"));
		srvEventType.setStatus = Utils.parseShort(map.get("setStatus"));
		return srvEventType;
	}
	
	
	
	/**字段设置标记队列**/
	private Map<String,Boolean> seted=new HashMap();
	public Boolean getSeted(String key){
		return seted.get(key);
	}
	public void setSeted(String key){
		seted.put(key,true);
	}
	/**同步未set的字段**/
	public void mergeSet(SrvEventType old){
		Field[] fields = this.getClass().getDeclaredFields();
		try {
			for(Field field:fields){
				String key = field.getName();
				if(seted.get(key)==null && field.getAnnotation(column.class)!=null){
					field.setAccessible(true);
					field.set(this, field.get(old));					
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
		
	/**自定义变量存储**/
	private Map values=new HashMap();
	public Map getValues(){
		return values;
	}
	public void setValues(String name,Object value){
		values.put(name,value);
	}
	
	/**分表时的表名后缀**/
	private String suffix;
	public String getSuffix() {
		return suffix;
	}
	public void setSuffix(String suffix) {
		this.suffix = suffix;
	}
	/**获取数据库名称**/
	public static String getDataBaseName(){
		return Utils.config("spring.datasource.distribute_sys.name");
	}
	
	public static String getIcon(){
		return "/images/icons/20088256421631277803.png";
	}
	public static String getIconfont(){
		return "icon-weixing";
	}
	public static enum ACT{
		列表,修改,详情
	};
	public static String getUrl(ACT act,SrvEventType.M params){
		if(params==null)params=new SrvEventType.M(0);
		params.remove("joins");
		params.remove("definexs");
		params.remove("distinct");
		String strUrl = "/admin/systematic/eventtype.edit.html?";
		if(params.get("setId")!=null){
			strUrl+="&id="+Utils.encode(""+params.get("setId"),Utils.UTF8);
		}
		if(act==ACT.列表){
			strUrl = "/admin/systematic/eventtype.html?1=1";
		}else if(act==ACT.修改){
			strUrl+="&edittype=update";
		}else if(act==ACT.详情){
			strUrl+="&edittype=detail";
		}		
		if(params!=null){
			for(Object key:params.keySet()){
				strUrl+="&"+key+"="+Utils.encode(""+params.get(key),Utils.UTF8)+"";
			}
		}
		return strUrl;
	}
	public String getDetailUrl(){
		return this.getUrl(ACT.详情, where.setId(this.getId()));
	}
	
	/**
	* 转跳到当前地址
	**/
	public static Protocol redirect(SrvEventType.ACT act,SrvEventType.M params){
		Protocol protocol = Protocol.create(true,null,"ACT_REDIRECT");
		protocol.set("url",SrvEventType.getUrl(act, params));
		return protocol;
	}
	/**
	* 打开一个新的tab页面
	**/
	public static Protocol href(SrvEventType.ACT act,SrvEventType.M params){
		Protocol protocol = Protocol.create(true,null,"ACT_HREF");
		protocol.set("url",SrvEventType.getUrl(act, params));
		protocol.set("title",act.name());
		return protocol;
	}
	/**
	* 显示一个消息框，并且关闭当前的对话框
	**/
	public static Protocol message(String message){
		Protocol protocol = Protocol.create(true,null,"ACT_MESSAGE");
		protocol.set("message",message);
		return protocol;
	}
	
	
	static com.distribute.framework.dao.ISrvEventTypeDao getSrvEventTypeDao(){
		return Utils.getBean("srvEventTypeDao");
	};
	
}